home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / GRAPHICS / COMMON.ZIP / FAR2.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-09  |  3.8 KB  |  162 lines
  1. #if 0
  2. In article <1995Dec8.143155.4386@nedcu0>, N S GHAI <ghai@imt.unine.ch> wrote:
  3.  
  4. > I have data from an image which is 80Kbytes. So by allocating the memory
  5. > using farmalloc()  I am able to fill the memory array, but when I try to
  6. > access it, the data is not accessable after 64Kbyte.(Because of
  7. > segmentation) .The outline of the code is here:
  8. > 
  9. > char far *mydata;
  10. > main()
  11. > {
  12. > long SIZE=80000;
  13. > char data;
  14. > if((mydata=(char far *)farmalloc(SIZE*sizeof(char))==NULL)
  15. > cout<<"MEMROY ALLOCATION ERROR";
  16. > Imagecopy(image,&mydata); //A function to copy the imagedata to                                
  17. !!! why &mydata?
  18.  
  19. AJR:
  20. I bet Imagecopy is defines as 
  21. Imagecopy(char far *src, char far *dest);
  22. in which case the & isn't needed.
  23.  
  24. > //mydata
  25. > for(long i=0; i < SIZE ;i++ )                                                        
  26. >    data=mydata[i];                 //To acess the data from the array
  27. >                                 //Here data remains valid till 'i'
  28. reaches                                      //65000  after
  29. >                                 //that it is not better.
  30. [snip]
  31.  
  32. In a Microsoft environment, "far" pointers only use 16 bit address
  33. arithmetic on the offset, causing the pointer to wrap at 64K. A "huge"
  34. pointer (not the same as huge memory model) uses 32 bit address
  35. arithmetic.
  36.  
  37. AJR writes:
  38. huge pointer will work, but be horribly slow.
  39. The compiler will re-normalize the pointer everytime you access it.
  40.  
  41. char huge *mydata;
  42. char huge *src;
  43.  
  44.  
  45. // slow using huge pointers, but adequate with todays fast cpu's
  46. Imagecopy(char huge *image, char huge *mydata, long size)
  47. {
  48.    while ( size )
  49.       {
  50.       *mydata++=*src++;
  51.       size--;
  52.       }
  53. }
  54.  
  55.  
  56. void foo(void)
  57. {
  58.    mydata=(char huge *)farmalloc(SIZE);
  59.    if ( mydata )
  60.       {
  61.       // src magiclly set somewhere else
  62.       Imagecopy(src, mydata, SIZE);
  63.       }
  64.    else
  65.       {
  66.       printf("rats! out of mem\n");
  67.       }
  68. }
  69.  
  70. #endif
  71.  
  72. // Now if we want the speed of far pointers we have to do the pointer
  73. // normalization ourselfs.
  74.  
  75.  
  76. #include <stdio.h>
  77. #include <malloc.h>
  78. #include <dos.h>
  79. #include <string.h>
  80.  
  81. #define SIZE 80000lu
  82. #define LESS64K 64000u
  83. // we don't use 65536u because a normalized pointer doesn't 
  84. // have an offset of zero very often
  85.  
  86. char far *mydata;
  87. char far *src;
  88.  
  89. /*
  90. _fmemcpy(unsigned char far *, unsigned char far *, unsigned int size);
  91.  
  92. If in a far memmodel you can just use plain memcpy(), but if in a near mem
  93. model must use a far version of memcpy()
  94.  
  95. in most compilers this is implemented with a rep movs so it is faster than the
  96. c loop used above.
  97.  
  98. */
  99.  
  100.  
  101. /* alter a far pointer so that the offset is zero,
  102.    handy if the data is actualy > 64k long */
  103. /* ---------------------- normalize() -------------------- March 26,1993 */
  104. char far *normalize(char far *p)
  105. {
  106.  
  107.    unsigned short seg,off;
  108.  
  109.     seg = FP_SEG(p);
  110.     off = FP_OFF(p);
  111.     seg += (off>>4);
  112.     off &= 0x000f;
  113.     p = MK_FP(seg,off);
  114.  
  115.    return(p);
  116. }
  117.  
  118. // NOT tested! probably works, but its just to show the technique
  119. // faster using far pointers
  120. void Imagecopy(char far *src, char far *mydata, long size)
  121. {
  122.    unsigned int i;
  123.    while ( size )
  124.       {
  125.       // normalize src and mydata
  126.       src=normalize(src);
  127.       mydata=normalize(mydata);
  128.  
  129.       i=LESS64K;
  130.       if ( size > i )
  131.          {
  132.          // copy 65000
  133.          _fmemcpy(src, mydata, LESS64K);
  134.          src+=LESS64K;
  135.          mydata+=LESS64K;
  136.          size-=LESS64K;
  137.          }
  138.       else
  139.          {
  140.          // copy remainder
  141.          _fmemcpy(src, mydata, size);
  142.          size=0;
  143.          }
  144.  
  145.       }
  146. }
  147.  
  148.  
  149. void foo(void)
  150. {
  151.    mydata=(char far *)farmalloc(SIZE);
  152.    if ( mydata )
  153.       {
  154.       // src magiclly set somewhere else
  155.       Imagecopy(src, mydata, SIZE);
  156.       }
  157.    else
  158.       {
  159.       printf("rats! out of mem\n");
  160.       }
  161. }
  162.